home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / var / lib / python-support / python2.6 / gdata / tlslite / messages.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  22.6 KB  |  647 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. '''Classes representing TLS messages.'''
  5. from utils.compat import *
  6. from utils.cryptomath import *
  7. from errors import *
  8. from utils.codec import *
  9. from constants import *
  10. from X509 import X509
  11. from X509CertChain import X509CertChain
  12. import sha
  13. import md5
  14.  
  15. class RecordHeader3:
  16.     
  17.     def __init__(self):
  18.         self.type = 0
  19.         self.version = (0, 0)
  20.         self.length = 0
  21.         self.ssl2 = False
  22.  
  23.     
  24.     def create(self, version, type, length):
  25.         self.type = type
  26.         self.version = version
  27.         self.length = length
  28.         return self
  29.  
  30.     
  31.     def write(self):
  32.         w = Writer(5)
  33.         w.add(self.type, 1)
  34.         w.add(self.version[0], 1)
  35.         w.add(self.version[1], 1)
  36.         w.add(self.length, 2)
  37.         return w.bytes
  38.  
  39.     
  40.     def parse(self, p):
  41.         self.type = p.get(1)
  42.         self.version = (p.get(1), p.get(1))
  43.         self.length = p.get(2)
  44.         self.ssl2 = False
  45.         return self
  46.  
  47.  
  48.  
  49. class RecordHeader2:
  50.     
  51.     def __init__(self):
  52.         self.type = 0
  53.         self.version = (0, 0)
  54.         self.length = 0
  55.         self.ssl2 = True
  56.  
  57.     
  58.     def parse(self, p):
  59.         if p.get(1) != 128:
  60.             raise SyntaxError()
  61.         p.get(1) != 128
  62.         self.type = ContentType.handshake
  63.         self.version = (2, 0)
  64.         self.length = p.get(1)
  65.         return self
  66.  
  67.  
  68.  
  69. class Msg:
  70.     
  71.     def preWrite(self, trial):
  72.         if trial:
  73.             w = Writer()
  74.         else:
  75.             length = self.write(True)
  76.             w = Writer(length)
  77.         return w
  78.  
  79.     
  80.     def postWrite(self, w, trial):
  81.         if trial:
  82.             return w.index
  83.         return w.bytes
  84.  
  85.  
  86.  
  87. class Alert(Msg):
  88.     
  89.     def __init__(self):
  90.         self.contentType = ContentType.alert
  91.         self.level = 0
  92.         self.description = 0
  93.  
  94.     
  95.     def create(self, description, level = AlertLevel.fatal):
  96.         self.level = level
  97.         self.description = description
  98.         return self
  99.  
  100.     
  101.     def parse(self, p):
  102.         p.setLengthCheck(2)
  103.         self.level = p.get(1)
  104.         self.description = p.get(1)
  105.         p.stopLengthCheck()
  106.         return self
  107.  
  108.     
  109.     def write(self):
  110.         w = Writer(2)
  111.         w.add(self.level, 1)
  112.         w.add(self.description, 1)
  113.         return w.bytes
  114.  
  115.  
  116.  
  117. class HandshakeMsg(Msg):
  118.     
  119.     def preWrite(self, handshakeType, trial):
  120.         if trial:
  121.             w = Writer()
  122.             w.add(handshakeType, 1)
  123.             w.add(0, 3)
  124.         else:
  125.             length = self.write(True)
  126.             w = Writer(length)
  127.             w.add(handshakeType, 1)
  128.             w.add(length - 4, 3)
  129.         return w
  130.  
  131.  
  132.  
  133. class ClientHello(HandshakeMsg):
  134.     
  135.     def __init__(self, ssl2 = False):
  136.         self.contentType = ContentType.handshake
  137.         self.ssl2 = ssl2
  138.         self.client_version = (0, 0)
  139.         self.random = createByteArrayZeros(32)
  140.         self.session_id = createByteArraySequence([])
  141.         self.cipher_suites = []
  142.         self.certificate_types = [
  143.             CertificateType.x509]
  144.         self.compression_methods = []
  145.         self.srp_username = None
  146.  
  147.     
  148.     def create(self, version, random, session_id, cipher_suites, certificate_types = None, srp_username = None):
  149.         self.client_version = version
  150.         self.random = random
  151.         self.session_id = session_id
  152.         self.cipher_suites = cipher_suites
  153.         self.certificate_types = certificate_types
  154.         self.compression_methods = [
  155.             0]
  156.         self.srp_username = srp_username
  157.         return self
  158.  
  159.     
  160.     def parse(self, p):
  161.         if self.ssl2:
  162.             self.client_version = (p.get(1), p.get(1))
  163.             cipherSpecsLength = p.get(2)
  164.             sessionIDLength = p.get(2)
  165.             randomLength = p.get(2)
  166.             self.cipher_suites = p.getFixList(3, int(cipherSpecsLength / 3))
  167.             self.session_id = p.getFixBytes(sessionIDLength)
  168.             self.random = p.getFixBytes(randomLength)
  169.             if len(self.random) < 32:
  170.                 zeroBytes = 32 - len(self.random)
  171.                 self.random = createByteArrayZeros(zeroBytes) + self.random
  172.             
  173.             self.compression_methods = [
  174.                 0]
  175.         else:
  176.             p.startLengthCheck(3)
  177.             self.client_version = (p.get(1), p.get(1))
  178.             self.random = p.getFixBytes(32)
  179.             self.session_id = p.getVarBytes(1)
  180.             self.cipher_suites = p.getVarList(2, 2)
  181.             self.compression_methods = p.getVarList(1, 1)
  182.             if not p.atLengthCheck():
  183.                 totalExtLength = p.get(2)
  184.                 soFar = 0
  185.                 while soFar != totalExtLength:
  186.                     extType = p.get(2)
  187.                     extLength = p.get(2)
  188.                     if extType == 6:
  189.                         self.srp_username = bytesToString(p.getVarBytes(1))
  190.                     elif extType == 7:
  191.                         self.certificate_types = p.getVarList(1, 1)
  192.                     else:
  193.                         p.getFixBytes(extLength)
  194.                     soFar += 4 + extLength
  195.             
  196.             p.stopLengthCheck()
  197.         return self
  198.  
  199.     
  200.     def write(self, trial = False):
  201.         w = HandshakeMsg.preWrite(self, HandshakeType.client_hello, trial)
  202.         w.add(self.client_version[0], 1)
  203.         w.add(self.client_version[1], 1)
  204.         w.addFixSeq(self.random, 1)
  205.         w.addVarSeq(self.session_id, 1, 1)
  206.         w.addVarSeq(self.cipher_suites, 2, 2)
  207.         w.addVarSeq(self.compression_methods, 1, 1)
  208.         extLength = 0
  209.         if self.certificate_types and self.certificate_types != [
  210.             CertificateType.x509]:
  211.             extLength += 5 + len(self.certificate_types)
  212.         
  213.         if self.srp_username:
  214.             extLength += 5 + len(self.srp_username)
  215.         
  216.         if extLength > 0:
  217.             w.add(extLength, 2)
  218.         
  219.         if self.certificate_types and self.certificate_types != [
  220.             CertificateType.x509]:
  221.             w.add(7, 2)
  222.             w.add(len(self.certificate_types) + 1, 2)
  223.             w.addVarSeq(self.certificate_types, 1, 1)
  224.         
  225.         if self.srp_username:
  226.             w.add(6, 2)
  227.             w.add(len(self.srp_username) + 1, 2)
  228.             w.addVarSeq(stringToBytes(self.srp_username), 1, 1)
  229.         
  230.         return HandshakeMsg.postWrite(self, w, trial)
  231.  
  232.  
  233.  
  234. class ServerHello(HandshakeMsg):
  235.     
  236.     def __init__(self):
  237.         self.contentType = ContentType.handshake
  238.         self.server_version = (0, 0)
  239.         self.random = createByteArrayZeros(32)
  240.         self.session_id = createByteArraySequence([])
  241.         self.cipher_suite = 0
  242.         self.certificate_type = CertificateType.x509
  243.         self.compression_method = 0
  244.  
  245.     
  246.     def create(self, version, random, session_id, cipher_suite, certificate_type):
  247.         self.server_version = version
  248.         self.random = random
  249.         self.session_id = session_id
  250.         self.cipher_suite = cipher_suite
  251.         self.certificate_type = certificate_type
  252.         self.compression_method = 0
  253.         return self
  254.  
  255.     
  256.     def parse(self, p):
  257.         p.startLengthCheck(3)
  258.         self.server_version = (p.get(1), p.get(1))
  259.         self.random = p.getFixBytes(32)
  260.         self.session_id = p.getVarBytes(1)
  261.         self.cipher_suite = p.get(2)
  262.         self.compression_method = p.get(1)
  263.         if not p.atLengthCheck():
  264.             totalExtLength = p.get(2)
  265.             soFar = 0
  266.             while soFar != totalExtLength:
  267.                 extType = p.get(2)
  268.                 extLength = p.get(2)
  269.                 if extType == 7:
  270.                     self.certificate_type = p.get(1)
  271.                 else:
  272.                     p.getFixBytes(extLength)
  273.                 soFar += 4 + extLength
  274.         
  275.         p.stopLengthCheck()
  276.         return self
  277.  
  278.     
  279.     def write(self, trial = False):
  280.         w = HandshakeMsg.preWrite(self, HandshakeType.server_hello, trial)
  281.         w.add(self.server_version[0], 1)
  282.         w.add(self.server_version[1], 1)
  283.         w.addFixSeq(self.random, 1)
  284.         w.addVarSeq(self.session_id, 1, 1)
  285.         w.add(self.cipher_suite, 2)
  286.         w.add(self.compression_method, 1)
  287.         extLength = 0
  288.         if self.certificate_type and self.certificate_type != CertificateType.x509:
  289.             extLength += 5
  290.         
  291.         if extLength != 0:
  292.             w.add(extLength, 2)
  293.         
  294.         if self.certificate_type and self.certificate_type != CertificateType.x509:
  295.             w.add(7, 2)
  296.             w.add(1, 2)
  297.             w.add(self.certificate_type, 1)
  298.         
  299.         return HandshakeMsg.postWrite(self, w, trial)
  300.  
  301.  
  302.  
  303. class Certificate(HandshakeMsg):
  304.     
  305.     def __init__(self, certificateType):
  306.         self.certificateType = certificateType
  307.         self.contentType = ContentType.handshake
  308.         self.certChain = None
  309.  
  310.     
  311.     def create(self, certChain):
  312.         self.certChain = certChain
  313.         return self
  314.  
  315.     
  316.     def parse(self, p):
  317.         p.startLengthCheck(3)
  318.         if self.certificateType == CertificateType.x509:
  319.             chainLength = p.get(3)
  320.             index = 0
  321.             certificate_list = []
  322.             while index != chainLength:
  323.                 certBytes = p.getVarBytes(3)
  324.                 x509 = X509()
  325.                 x509.parseBinary(certBytes)
  326.                 certificate_list.append(x509)
  327.                 index += len(certBytes) + 3
  328.             if certificate_list:
  329.                 self.certChain = X509CertChain(certificate_list)
  330.             
  331.         elif self.certificateType == CertificateType.cryptoID:
  332.             s = bytesToString(p.getVarBytes(2))
  333.             if s:
  334.                 
  335.                 try:
  336.                     import cryptoIDlib.CertChain as cryptoIDlib
  337.                 except ImportError:
  338.                     raise SyntaxError('cryptoID cert chain received, cryptoIDlib not present')
  339.  
  340.                 self.certChain = cryptoIDlib.CertChain.CertChain().parse(s)
  341.             
  342.         else:
  343.             raise AssertionError()
  344.         (self.certificateType == CertificateType.x509).stopLengthCheck()
  345.         return self
  346.  
  347.     
  348.     def write(self, trial = False):
  349.         w = HandshakeMsg.preWrite(self, HandshakeType.certificate, trial)
  350.         if self.certificateType == CertificateType.x509:
  351.             chainLength = 0
  352.             if self.certChain:
  353.                 certificate_list = self.certChain.x509List
  354.             else:
  355.                 certificate_list = []
  356.             for cert in certificate_list:
  357.                 bytes = cert.writeBytes()
  358.                 chainLength += len(bytes) + 3
  359.             
  360.             w.add(chainLength, 3)
  361.             for cert in certificate_list:
  362.                 bytes = cert.writeBytes()
  363.                 w.addVarSeq(bytes, 1, 3)
  364.             
  365.         elif self.certificateType == CertificateType.cryptoID:
  366.             if self.certChain:
  367.                 bytes = stringToBytes(self.certChain.write())
  368.             else:
  369.                 bytes = createByteArraySequence([])
  370.             w.addVarSeq(bytes, 1, 2)
  371.         else:
  372.             raise AssertionError()
  373.         return (self.certificateType == CertificateType.x509).postWrite(self, w, trial)
  374.  
  375.  
  376.  
  377. class CertificateRequest(HandshakeMsg):
  378.     
  379.     def __init__(self):
  380.         self.contentType = ContentType.handshake
  381.         self.certificate_types = []
  382.         self.certificate_authorities = createByteArraySequence([])
  383.  
  384.     
  385.     def create(self, certificate_types, certificate_authorities):
  386.         self.certificate_types = certificate_types
  387.         self.certificate_authorities = certificate_authorities
  388.         return self
  389.  
  390.     
  391.     def parse(self, p):
  392.         p.startLengthCheck(3)
  393.         self.certificate_types = p.getVarList(1, 1)
  394.         self.certificate_authorities = p.getVarBytes(2)
  395.         p.stopLengthCheck()
  396.         return self
  397.  
  398.     
  399.     def write(self, trial = False):
  400.         w = HandshakeMsg.preWrite(self, HandshakeType.certificate_request, trial)
  401.         w.addVarSeq(self.certificate_types, 1, 1)
  402.         w.addVarSeq(self.certificate_authorities, 1, 2)
  403.         return HandshakeMsg.postWrite(self, w, trial)
  404.  
  405.  
  406.  
  407. class ServerKeyExchange(HandshakeMsg):
  408.     
  409.     def __init__(self, cipherSuite):
  410.         self.cipherSuite = cipherSuite
  411.         self.contentType = ContentType.handshake
  412.         self.srp_N = 0x0L
  413.         self.srp_g = 0x0L
  414.         self.srp_s = createByteArraySequence([])
  415.         self.srp_B = 0x0L
  416.         self.signature = createByteArraySequence([])
  417.  
  418.     
  419.     def createSRP(self, srp_N, srp_g, srp_s, srp_B):
  420.         self.srp_N = srp_N
  421.         self.srp_g = srp_g
  422.         self.srp_s = srp_s
  423.         self.srp_B = srp_B
  424.         return self
  425.  
  426.     
  427.     def parse(self, p):
  428.         p.startLengthCheck(3)
  429.         self.srp_N = bytesToNumber(p.getVarBytes(2))
  430.         self.srp_g = bytesToNumber(p.getVarBytes(2))
  431.         self.srp_s = p.getVarBytes(1)
  432.         self.srp_B = bytesToNumber(p.getVarBytes(2))
  433.         if self.cipherSuite in CipherSuite.srpRsaSuites:
  434.             self.signature = p.getVarBytes(2)
  435.         
  436.         p.stopLengthCheck()
  437.         return self
  438.  
  439.     
  440.     def write(self, trial = False):
  441.         w = HandshakeMsg.preWrite(self, HandshakeType.server_key_exchange, trial)
  442.         w.addVarSeq(numberToBytes(self.srp_N), 1, 2)
  443.         w.addVarSeq(numberToBytes(self.srp_g), 1, 2)
  444.         w.addVarSeq(self.srp_s, 1, 1)
  445.         w.addVarSeq(numberToBytes(self.srp_B), 1, 2)
  446.         if self.cipherSuite in CipherSuite.srpRsaSuites:
  447.             w.addVarSeq(self.signature, 1, 2)
  448.         
  449.         return HandshakeMsg.postWrite(self, w, trial)
  450.  
  451.     
  452.     def hash(self, clientRandom, serverRandom):
  453.         oldCipherSuite = self.cipherSuite
  454.         self.cipherSuite = None
  455.         
  456.         try:
  457.             bytes = clientRandom + serverRandom + self.write()[4:]
  458.             s = bytesToString(bytes)
  459.             return stringToBytes(md5.md5(s).digest() + sha.sha(s).digest())
  460.         finally:
  461.             self.cipherSuite = oldCipherSuite
  462.  
  463.  
  464.  
  465.  
  466. class ServerHelloDone(HandshakeMsg):
  467.     
  468.     def __init__(self):
  469.         self.contentType = ContentType.handshake
  470.  
  471.     
  472.     def create(self):
  473.         return self
  474.  
  475.     
  476.     def parse(self, p):
  477.         p.startLengthCheck(3)
  478.         p.stopLengthCheck()
  479.         return self
  480.  
  481.     
  482.     def write(self, trial = False):
  483.         w = HandshakeMsg.preWrite(self, HandshakeType.server_hello_done, trial)
  484.         return HandshakeMsg.postWrite(self, w, trial)
  485.  
  486.  
  487.  
  488. class ClientKeyExchange(HandshakeMsg):
  489.     
  490.     def __init__(self, cipherSuite, version = None):
  491.         self.cipherSuite = cipherSuite
  492.         self.version = version
  493.         self.contentType = ContentType.handshake
  494.         self.srp_A = 0
  495.         self.encryptedPreMasterSecret = createByteArraySequence([])
  496.  
  497.     
  498.     def createSRP(self, srp_A):
  499.         self.srp_A = srp_A
  500.         return self
  501.  
  502.     
  503.     def createRSA(self, encryptedPreMasterSecret):
  504.         self.encryptedPreMasterSecret = encryptedPreMasterSecret
  505.         return self
  506.  
  507.     
  508.     def parse(self, p):
  509.         p.startLengthCheck(3)
  510.         if self.cipherSuite in CipherSuite.srpSuites + CipherSuite.srpRsaSuites:
  511.             self.srp_A = bytesToNumber(p.getVarBytes(2))
  512.         elif self.cipherSuite in CipherSuite.rsaSuites:
  513.             if self.version in ((3, 1), (3, 2)):
  514.                 self.encryptedPreMasterSecret = p.getVarBytes(2)
  515.             elif self.version == (3, 0):
  516.                 self.encryptedPreMasterSecret = p.getFixBytes(len(p.bytes) - p.index)
  517.             else:
  518.                 raise AssertionError()
  519.         self.version in ((3, 1), (3, 2))
  520.         raise AssertionError()
  521.         p.stopLengthCheck()
  522.         return self
  523.  
  524.     
  525.     def write(self, trial = False):
  526.         w = HandshakeMsg.preWrite(self, HandshakeType.client_key_exchange, trial)
  527.         if self.cipherSuite in CipherSuite.srpSuites + CipherSuite.srpRsaSuites:
  528.             w.addVarSeq(numberToBytes(self.srp_A), 1, 2)
  529.         elif self.cipherSuite in CipherSuite.rsaSuites:
  530.             if self.version in ((3, 1), (3, 2)):
  531.                 w.addVarSeq(self.encryptedPreMasterSecret, 1, 2)
  532.             elif self.version == (3, 0):
  533.                 w.addFixSeq(self.encryptedPreMasterSecret, 1)
  534.             else:
  535.                 raise AssertionError()
  536.         self.version in ((3, 1), (3, 2))
  537.         raise AssertionError()
  538.         return HandshakeMsg.postWrite(self, w, trial)
  539.  
  540.  
  541.  
  542. class CertificateVerify(HandshakeMsg):
  543.     
  544.     def __init__(self):
  545.         self.contentType = ContentType.handshake
  546.         self.signature = createByteArraySequence([])
  547.  
  548.     
  549.     def create(self, signature):
  550.         self.signature = signature
  551.         return self
  552.  
  553.     
  554.     def parse(self, p):
  555.         p.startLengthCheck(3)
  556.         self.signature = p.getVarBytes(2)
  557.         p.stopLengthCheck()
  558.         return self
  559.  
  560.     
  561.     def write(self, trial = False):
  562.         w = HandshakeMsg.preWrite(self, HandshakeType.certificate_verify, trial)
  563.         w.addVarSeq(self.signature, 1, 2)
  564.         return HandshakeMsg.postWrite(self, w, trial)
  565.  
  566.  
  567.  
  568. class ChangeCipherSpec(Msg):
  569.     
  570.     def __init__(self):
  571.         self.contentType = ContentType.change_cipher_spec
  572.         self.type = 1
  573.  
  574.     
  575.     def create(self):
  576.         self.type = 1
  577.         return self
  578.  
  579.     
  580.     def parse(self, p):
  581.         p.setLengthCheck(1)
  582.         self.type = p.get(1)
  583.         p.stopLengthCheck()
  584.         return self
  585.  
  586.     
  587.     def write(self, trial = False):
  588.         w = Msg.preWrite(self, trial)
  589.         w.add(self.type, 1)
  590.         return Msg.postWrite(self, w, trial)
  591.  
  592.  
  593.  
  594. class Finished(HandshakeMsg):
  595.     
  596.     def __init__(self, version):
  597.         self.contentType = ContentType.handshake
  598.         self.version = version
  599.         self.verify_data = createByteArraySequence([])
  600.  
  601.     
  602.     def create(self, verify_data):
  603.         self.verify_data = verify_data
  604.         return self
  605.  
  606.     
  607.     def parse(self, p):
  608.         p.startLengthCheck(3)
  609.         if self.version == (3, 0):
  610.             self.verify_data = p.getFixBytes(36)
  611.         elif self.version in ((3, 1), (3, 2)):
  612.             self.verify_data = p.getFixBytes(12)
  613.         else:
  614.             raise AssertionError()
  615.         (self.version == (3, 0)).stopLengthCheck()
  616.         return self
  617.  
  618.     
  619.     def write(self, trial = False):
  620.         w = HandshakeMsg.preWrite(self, HandshakeType.finished, trial)
  621.         w.addFixSeq(self.verify_data, 1)
  622.         return HandshakeMsg.postWrite(self, w, trial)
  623.  
  624.  
  625.  
  626. class ApplicationData(Msg):
  627.     
  628.     def __init__(self):
  629.         self.contentType = ContentType.application_data
  630.         self.bytes = createByteArraySequence([])
  631.  
  632.     
  633.     def create(self, bytes):
  634.         self.bytes = bytes
  635.         return self
  636.  
  637.     
  638.     def parse(self, p):
  639.         self.bytes = p.bytes
  640.         return self
  641.  
  642.     
  643.     def write(self):
  644.         return self.bytes
  645.  
  646.  
  647.